start_server {tags {"maxmemory"}} {
    test "Config get maxmemory." {
        set maxm [r config get maxmemory]
        assert {$maxm > 1}
    }

    # The current maxmemory command does not support config set and policy.
    # For a complete list of commands, refer to the wiki: https://github.com/OpenAtomFoundation/pika/wiki/pika-%E5%B7%AE%E5%BC%82%E5%8C%96%E5%91%BD%E4%BB%A4

    # test "Without maxmemory small integers are shared" {
    #     r config set maxmemory 0
    #     r set a 1
    #     assert {[r object refcount a] > 1}
    # }

    # test "With maxmemory and non-LRU policy integers are still shared" {
    #     r config set maxmemory 1073741824
    #     r config set maxmemory-policy allkeys-random
    #     r set a 1
    #     assert {[r object refcount a] > 1}
    # }

    # test "With maxmemory and LRU policy integers are not shared" {
    #     r config set maxmemory 1073741824
    #     r config set maxmemory-policy allkeys-lru
    #     r set a 1
    #     r config set maxmemory-policy volatile-lru
    #     r set b 1
    #     assert {[r object refcount a] == 1}
    #     assert {[r object refcount b] == 1}
    #     r config set maxmemory 0
    # }

    # foreach policy {
    #     allkeys-random allkeys-lru volatile-lru volatile-random volatile-ttl
    # } {
    #     test "maxmemory - is the memory limit honoured? (policy $policy)" {
    #         # make sure to start with a blank instance
    #         r flushall
    #         # Get the current memory limit and calculate a new limit.
    #         # We just add 100k to the current memory size so that it is
    #         # fast for us to reach that limit.
    #         set used [s used_memory]
    #         set limit [expr {$used+100*1024}]
    #         r config set maxmemory $limit
    #         r config set maxmemory-policy $policy
    #         # Now add keys until the limit is almost reached.
    #         set numkeys 0
    #         while 1 {
    #             r setex [randomKey] 10000 x
    #             incr numkeys
    #             if {[s used_memory]+4096 > $limit} {
    #                 assert {$numkeys > 10}
    #                 break
    #             }
    #         }
    #         # If we add the same number of keys already added again, we
    #         # should still be under the limit.
    #         for {set j 0} {$j < $numkeys} {incr j} {
    #             r setex [randomKey] 10000 x
    #         }
    #         assert {[s used_memory] < ($limit+4096)}
    #     }
    # }

    # foreach policy {
    #     allkeys-random allkeys-lru volatile-lru volatile-random volatile-ttl
    # } {
    #     test "maxmemory - only allkeys-* should remove non-volatile keys ($policy)" {
    #         # make sure to start with a blank instance
    #         r flushall
    #         # Get the current memory limit and calculate a new limit.
    #         # We just add 100k to the current memory size so that it is
    #         # fast for us to reach that limit.
    #         set used [s used_memory]
    #         set limit [expr {$used+100*1024}]
    #         r config set maxmemory $limit
    #         r config set maxmemory-policy $policy
    #         # Now add keys until the limit is almost reached.
    #         set numkeys 0
    #         while 1 {
    #             r set [randomKey] x
    #             incr numkeys
    #             if {[s used_memory]+4096 > $limit} {
    #                 assert {$numkeys > 10}
    #                 break
    #             }
    #         }
    #         # If we add the same number of keys already added again and
    #         # the policy is allkeys-* we should still be under the limit.
    #         # Otherwise we should see an error reported by Redis.
    #         set err 0
    #         for {set j 0} {$j < $numkeys} {incr j} {
    #             if {[catch {r set [randomKey] x} e]} {
    #                 if {[string match {*used memory*} $e]} {
    #                     set err 1
    #                 }
    #             }
    #         }
    #         if {[string match allkeys-* $policy]} {
    #             assert {[s used_memory] < ($limit+4096)}
    #         } else {
    #             assert {$err == 1}
    #         }
    #     }
    # }

    # foreach policy {
    #     volatile-lru volatile-random volatile-ttl
    # } {
    #     test "maxmemory - policy $policy should only remove volatile keys." {
    #         # make sure to start with a blank instance
    #         r flushall
    #         # Get the current memory limit and calculate a new limit.
    #         # We just add 100k to the current memory size so that it is
    #         # fast for us to reach that limit.
    #         set used [s used_memory]
    #         set limit [expr {$used+100*1024}]
    #         r config set maxmemory $limit
    #         r config set maxmemory-policy $policy
    #         # Now add keys until the limit is almost reached.
    #         set numkeys 0
    #         while 1 {
    #             # Odd keys are volatile
    #             # Even keys are non volatile
    #             if {$numkeys % 2} {
    #                 r setex "key:$numkeys" 10000 x
    #             } else {
    #                 r set "key:$numkeys" x
    #             }
    #             if {[s used_memory]+4096 > $limit} {
    #                 assert {$numkeys > 10}
    #                 break
    #             }
    #             incr numkeys
    #         }
    #         # Now we add the same number of volatile keys already added.
    #         # We expect Redis to evict only volatile keys in order to make
    #         # space.
    #         set err 0
    #         for {set j 0} {$j < $numkeys} {incr j} {
    #             catch {r setex "foo:$j" 10000 x}
    #         }
    #         # We should still be under the limit.
    #         assert {[s used_memory] < ($limit+4096)}
    #         # However all our non volatile keys should be here.
    #         for {set j 0} {$j < $numkeys} {incr j 2} {
    #             assert {[r exists "key:$j"]}
    #         }
    #     }
    # }
}
